package com.feilong.commons.core.date;

import static com.feilong.commons.core.PropertiesConstants.config_date_day;
import static com.feilong.commons.core.PropertiesConstants.config_date_hour;
import static com.feilong.commons.core.PropertiesConstants.config_date_millisecond;
import static com.feilong.commons.core.PropertiesConstants.config_date_minute;
import static com.feilong.commons.core.PropertiesConstants.config_date_second;
import static com.feilong.commons.core.PropertiesConstants.config_date_theDayBeforeYesterday;
import static com.feilong.commons.core.PropertiesConstants.config_date_yesterday;

import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.LinkedList;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.feilong.commons.core.text.DateFormatUtil;
import com.feilong.commons.core.util.RegexUtil;
import com.feilong.commons.core.util.Validator;

/**
 * 日期操作的类(feilong-core 核心类之一)<br>
 * 包括通用的:字符串转日期,日期转字符串操作
 * 
 * @author <a href="venusdrogon@163.com">金鑫</a>
 * @see CalendarUtil
 * @see DatePattern
 * @version 1.0 2010-1-27 下午01:53:21
 * @since 1.0
 */
public final class DateUtil{

	private final static Logger	log	= LoggerFactory.getLogger(DateUtil.class);

	/** Don't let anyone instantiate this class. */
	private DateUtil(){}

	/** ***************************************************************************************** */
	/**
	 * 按照同样格式转成Date类型,判断 date_before 是否早于date_after<br>
	 * 比如,isBefore("2011-05-01","2011-04-01",com.feilong.commons.core.date.DateUtil.pattern_onlyDate) 返回 true
	 * 
	 * @param date_before
	 *            date_before
	 * @param date_after
	 *            date_after
	 * @param datePattern
	 *            pattern
	 * @return 如果date_before 早于 date_after返回 true
	 */
	public final static boolean isBefore(String date_before,String date_after,String datePattern){
		Date date_1 = DateUtil.string2Date(date_before, datePattern);
		Date date_2 = DateUtil.string2Date(date_after, datePattern);
		return date_1.before(date_2);
	}

	/**
	 * 获得当天0:00:00及下一天0:00:00,一般用于统计当天数据,between ... and ...
	 * 
	 * @return Date数组 第一个为today 第二个为tomorrow
	 * @since 1.0
	 */
	public final static Date[] getExtentToday(){
		Calendar calendar = CalendarUtil.getResetTodayCalendar_byDay();
		Date today = calendar.getTime();
		// ***************************
		calendar.add(Calendar.DATE, 1);
		Date tomorrow = calendar.getTime();
		Date[] dates = { today, tomorrow };
		return dates;
	}

	/**
	 * 获得昨天/ 日期的前一天的此时此刻
	 * <p>
	 * 仅对天数-1,其余时间部分未作处理
	 * </p>
	 * 
	 * @param date
	 *            date
	 * @return 获得昨天/ 日期的前一天
	 * @since 1.0
	 */
	public final static Date getYesterday(Date date){
		Calendar calendar = toCalendar(date);
		calendar.add(Calendar.DATE, -1);
		return calendar.getTime();
	}

	/**
	 * 获得昨天的区间 [yestoday,today]<br>
	 * 第一个为昨天00:00 <br>
	 * 第二个为今天00:00 <br>
	 * 一般用于sql/hql统计昨天数据,between ... and ...
	 * 
	 * @return Date数组 <br>
	 *         第一个为昨天00:00 <br>
	 *         第二个为今天00:00
	 * @since 1.0
	 */
	public final static Date[] getExtentYesterday(){
		Calendar calendar = CalendarUtil.getResetTodayCalendar_byDay();
		Date today = calendar.getTime();
		calendar.add(Calendar.DATE, -1);
		Date yesterday = calendar.getTime();
		Date[] dates = { yesterday, today };
		return dates;
	}

	/**
	 * 获得传入date 所在星期的第一天(周日) 0:0:0:0 到毫秒<br>
	 * 注意:按照外国制,周日为一个星期第一天,周六为最后一天
	 * 
	 * <pre>
	 * 如果 现在是 2012-10-11 17:10:30.701 (周四),
	 * 
	 * return  2012-10-07 00:00:00.000
	 * 
	 * </pre>
	 * 
	 * @return Date
	 * @since 1.0
	 */
	public final static Date getFirstDateOfThisWeek(Date date){
		Calendar calendar = toCalendar(date);
		calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
		dayBegin(calendar);
		return calendar.getTime();
	}

	/**
	 * 获得传入date 所在星期的最后一天(周六) 23:59:59.999 到毫秒<br>
	 * 注意:按照外国制,周日为一个星期第一天,周六为最后一天
	 * 
	 * <pre>
	 * 如果 现在是 2012-10-11 17:10:30.701 (周四),
	 * 
	 * return  2012-10-13 23:59:59.999
	 * 
	 * </pre>
	 * 
	 * @param date
	 *            任意date
	 * @return 传入date 所在星期的最后一天 23:59:59.999 到毫秒
	 * @since 1.0.1
	 */
	public final static Date getLastDateOfThisWeek(Date date){
		Calendar calendar = toCalendar(date);
		calendar.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
		dayEnd(calendar);
		return calendar.getTime();
	}

	/**
	 * 获得当天所在月的第一天,0:0:0:0 到毫秒<br>
	 * 
	 * <pre>
	 * 如果 现在是 2012-10-11 17:10:30.701 (周四),
	 * 
	 * return 2012-10-01 00:00:00
	 * </pre>
	 * 
	 * @param date
	 * @return Date
	 * @since 1.0
	 */
	public final static Date getFirstDateOfThisMonth(Date date){
		Calendar calendar = toCalendar(date);
		calendar.set(Calendar.DAY_OF_MONTH, 1);
		dayBegin(calendar);
		return calendar.getTime();
	}

	/**
	 * 获得当天所在月的最后一天 23:59:59.999 到毫秒<br>
	 * 
	 * <pre>
	 * 如果 现在是 2012-10-11 17:10:30.701,
	 * 
	 * return 2012-10-31 23:59:59.999
	 * </pre>
	 * 
	 * @param date
	 * @return Date
	 * @since 1.0
	 */
	public final static Date getLastDateOfThisMonth(Date date){
		Calendar calendar = toCalendar(date);
		calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
		dayEnd(calendar);
		return calendar.getTime();
	}

	/**
	 * 获得指定日期所在年的第一天,0:0:0:0 到毫秒
	 * 
	 * <pre>
	 * 如果 现在是 2012-10-11 17:10:30.701,
	 * 
	 * return 2012-01-01 00:00:00
	 * </pre>
	 * 
	 * @param date
	 *            指定日期
	 * @return date
	 * @since 1.0
	 */
	public final static Date getFirstDateOfThisYear(Date date){
		Calendar calendar = toCalendar(date);
		calendar.set(Calendar.MONTH, Calendar.JANUARY);
		calendar.set(Calendar.DAY_OF_MONTH, 1);
		dayBegin(calendar);
		return calendar.getTime();
	}

	/**
	 * 获得当天所在年的最后一天 23:59:59.999 到毫秒<br>
	 * 
	 * <pre>
	 * 如果 现在是 2012-10-11 17:10:30.701,
	 * 
	 * return 2012-12-31 23:59:59.999
	 * </pre>
	 * 
	 * @param date
	 *            任意date
	 * @return Date
	 * @since 1.0
	 */
	public final static Date getLastDateOfThisYear(Date date){
		Calendar calendar = toCalendar(date);
		calendar.set(Calendar.MONTH, Calendar.DECEMBER);
		calendar.set(Calendar.DAY_OF_MONTH, 31);
		dayEnd(calendar);
		return calendar.getTime();
	}

	/**
	 * 一天开始,0:0:0.0
	 * 
	 * @param calendar
	 */
	private static void dayBegin(Calendar calendar){
		calendar.set(Calendar.HOUR_OF_DAY, 0);
		calendar.set(Calendar.MINUTE, 0);
		calendar.set(Calendar.SECOND, 0);
		calendar.set(Calendar.MILLISECOND, 0);
	}

	/**
	 * 一天结束,最后的时间 23:59:59.999
	 * 
	 * @param calendar
	 */
	private static void dayEnd(Calendar calendar){
		calendar.set(Calendar.HOUR_OF_DAY, 23);
		calendar.set(Calendar.MINUTE, 59);
		calendar.set(Calendar.SECOND, 59);
		calendar.set(Calendar.MILLISECOND, 999);
	}

	/**
	 * 判断当前时间是否在两个时间之间
	 * 
	 * @param beginTime
	 *            开始时间
	 * @param endTime
	 *            结束时间
	 * @return 如果当前时间after beginTimeDate并且当前时间before endTimeDate,返回true
	 * @since 1.0
	 */
	public final static boolean isInTime(String beginTime,String endTime,String datePattern){
		Date date = new Date();
		Date beginTimeDate = string2Date(beginTime, datePattern);
		Date endTimeDate = string2Date(endTime, datePattern);
		boolean flag = date.after(beginTimeDate) && date.before(endTimeDate);
		return flag;
	}

	// [start] 时间操作(加减)
	/** *********************** 时间操作(加减) **************************************** */
	/**
	 * 指定时间加减年份 <br>
	 * 2012-06-29 00:33:05,5 返回2017-06-29 00:33:05<br>
	 * 2012-06-29 00:33:05,-5 返回2007-06-29 00:33:05<br>
	 * 
	 * @param date
	 *            指定时间
	 * @param year
	 *            增加年份 可以是负数 表示前面多少
	 * @return 加减年份后的时间
	 * @since 1.0
	 */
	public final static Date addYear(Date date,int year){
		return operateDate(date, Calendar.YEAR, year);
	}

	/**
	 * 指定时间加减月份 <br>
	 * 2012-06-29 00:40:55,5 返回2012-11-29 00:40:55<br>
	 * 2012-06-29 00:40:55,-5 返回2012-01-29 00:40:55<br>
	 * 
	 * @param date
	 *            指定时间
	 * @param month
	 *            加减月份 可以是负数 表示前面多少<br>
	 *            比如-3 表示 3个月之前
	 * @return 加减月份后的时间
	 */
	public final static Date addMonth(Date date,int month){
		return operateDate(date, Calendar.MONTH, month);
	}

	/**
	 * 指定时间加减天数 <br>
	 * 2012-06-29 00:42:26,5 返回2012-07-04 00:42:26<br>
	 * 2012-06-29 00:42:26,-5 返回2012-06-24 00:42:26<br>
	 * 
	 * @param date
	 *            指定时间
	 * @param day
	 *            需要加减的天数 可以为负数
	 * @return 日期加减天数
	 * @since 1.0
	 */
	public final static Date addDay(Date date,int day){
		return operateDate(date, Calendar.DAY_OF_MONTH, day);
	}

	/**
	 * 日期加减星期 WEEK_OF_YEAR <br>
	 * 2012-06-29 00:45:18,5 返回2012-08-03 00:45:18<br>
	 * 2012-06-29 00:45:18,-5 返回2012-05-25 00:45:18<br>
	 * 
	 * @param date
	 *            指定时间
	 * @param week
	 *            需要加减的星期数 可以为负数
	 * @return 指定时间加减星期
	 * @since 1.0
	 */
	public final static Date addWeek(Date date,int week){
		return operateDate(date, Calendar.WEEK_OF_YEAR, week);
	}

	/**
	 * 日期加减小时 Calendar.HOUR_OF_DAY 24小时制 <br>
	 * 2012-06-29 00:46:24,5 返回2012-06-29 05:46:24<br>
	 * 2012-06-29 00:46:24,-5 返回2012-06-28 19:46:24<br>
	 * 
	 * @param date
	 * @param hour
	 * @return
	 */
	public final static Date addHour(Date date,int hour){
		return operateDate(date, Calendar.HOUR_OF_DAY, hour);
	}

	/**
	 * 日期加减分钟 Calendar.MINUTE
	 * 
	 * @param date
	 * @param minute
	 * @return
	 */
	public final static Date addMinute(Date date,int minute){
		return operateDate(date, Calendar.MINUTE, minute);
	}

	/**
	 * 日期加减秒 Calendar.SECOND
	 * 
	 * @param date
	 *            任意时间
	 * @param second
	 * @return
	 */
	public final static Date addSecond(Date date,int second){
		return operateDate(date, Calendar.SECOND, second);
	}

	/**
	 * 底层操作时间的方法
	 * <p>
	 * 根据日历的规则，为给定的日历字段添加或减去指定的时间量
	 * 
	 * @param currentDate
	 *            当前date
	 * @param field
	 *            日历字段
	 * @param amount
	 *            为字段添加的日期或时间量,可以为负数
	 * @return 底层操作时间的方法 根据日历的规则，为给定的日历字段添加或减去指定的时间量
	 * @since 1.0
	 */
	public final static Date operateDate(Date currentDate,int field,int amount){
		Calendar calendar = toCalendar(currentDate);
		calendar.add(field, amount);
		return calendar.getTime();
	}

	// [end]
	// [start] 底层取到数据
	/**
	 * 获得任意日期中的年份部分<br>
	 * 2012-06-29,直接返回2012
	 * 
	 * @param date
	 * @return 获得任意日期中的年份部分
	 * @since 1.0
	 */
	public final static int getYear(Date date){
		return CalendarUtil.getCalendarFieldValue(date, Calendar.YEAR);
	}

	/**
	 * 获得任意日期中的月份(已经+1处理)<br>
	 * 即2012-06-29,直接返回6
	 * 
	 * @param date
	 * @return 获得任意日期中的月份
	 * @since 1.0
	 */
	public final static int getMonth(Date date){
		return CalendarUtil.getCalendarFieldValue(date, Calendar.MONTH) + 1;
	}

	/**
	 * 获得任意时间中的天<br>
	 * 2012-06-29 返回 29
	 * 
	 * @param date
	 * @return 获得任意时间中的天
	 * @since 1.0
	 */
	public final static int getDayOfMonth(Date date){
		return CalendarUtil.getCalendarFieldValue(date, Calendar.DAY_OF_MONTH);
	}

	/**
	 * 获得当前日期星期几<br>
	 * 从星期天开始,并且星期天是1<br>
	 * 2012-06-29 是星期5 ,返回6
	 * 
	 * @param date
	 * @return
	 * @see Calendar#SUNDAY
	 * @see Calendar#MONDAY
	 * @see Calendar#TUESDAY
	 * @see Calendar#WEDNESDAY
	 * @see Calendar#THURSDAY
	 * @see Calendar#FRIDAY
	 * @see Calendar#SATURDAY
	 */
	public final static int getDayOfWeek(Date date){
		return CalendarUtil.getCalendarFieldValue(date, Calendar.DAY_OF_WEEK);
	}

	/**
	 * 获得时间中的小时(24小时制)<br>
	 * 2012-6-29 00:25,返回0
	 * 
	 * @param date
	 *            date
	 * @return 获得时间中的小时
	 * @since 1.0
	 */
	public final static int getHourOfDay(Date date){
		return CalendarUtil.getCalendarFieldValue(date, Calendar.HOUR_OF_DAY);
	}

	/**
	 * 获得时间中的分钟<br>
	 * 2012-6-29 00:26 返回26
	 * 
	 * @param date
	 *            date
	 * @return 获得时间中的分钟
	 * @since 1.0
	 */
	public final static int getMinute(Date date){
		return CalendarUtil.getCalendarFieldValue(date, Calendar.MINUTE);
	}

	/**
	 * 获得时间中的秒<br>
	 * 2012-6-29 00:26:53 返回53
	 * 
	 * @param date
	 *            date
	 * @return 获得时间中的秒
	 * @since 1.0
	 */
	public final static int getSecond(Date date){
		return CalendarUtil.getCalendarFieldValue(date, Calendar.SECOND);
	}

	/**
	 * 获得时间的毫秒数<br>
	 * 2012-6-29 00:28 返回1340900883288
	 * 
	 * @param date
	 *            date
	 * @return date
	 * @since 1.0
	 */
	public final static long getTime(Date date){
		return date.getTime();
	}

	// [end]
	/**
	 * 判断某年是否为闰年
	 * 
	 * @param yearNum
	 *            年份
	 * @return 闰年true
	 * @since 1.0
	 */
	public final static boolean isLeapYear(int yearNum){
		return (yearNum % 4 == 0 && yearNum % 100 != 0) || yearNum % 400 == 0;
	}

	// [start] 类型转换

	/**
	 * 不带参数pattern的 的method,采用默认 pattern--->{@link DatePattern#commonWithTime}
	 * 
	 * @param date
	 *            任意时间
	 * @return use {@link DatePattern#commonWithTime} format
	 */
	public final static String date2String(Date date){
		String defaultPattern = DatePattern.commonWithTime;
		return date2String(date, defaultPattern);
	}

	/**
	 * 将时间转换成特殊格式的字符串
	 * 
	 * @param date
	 *            任意时间
	 * @param datePattern
	 *            模式
	 * @return string
	 * @since 1.0
	 */
	public final static String date2String(Date date,String datePattern){
		return DateFormatUtil.format(date, datePattern);
	}

	/**
	 * 将日期集合装成特定pattern的字符串集合
	 * 
	 * @param dateList
	 *            日期集合
	 * @param datePattern
	 *            模式
	 * @return List<String>
	 * @since 1.0
	 */
	public final static List<String> dateList2StringList(List<Date> dateList,String datePattern){
		if (Validator.isNotNullOrEmpty(dateList)){
			List<String> stringList = new LinkedList<String>();
			for (Date date : dateList){
				stringList.add(date2String(date, datePattern));
			}
			return stringList;
		}
		return null;
	}

	/**
	 * 将时间string字符串转换成date类型
	 * 
	 * @param dateString
	 *            时间字符串
	 * @param datePattern
	 *            模式,时间字符串的模式
	 * @return 将string字符串转换成date类型
	 * @since 1.0
	 */
	public final static Date string2Date(String dateString,String datePattern){
		return DateFormatUtil.parse(dateString, datePattern);
	}

	/**
	 * 将出生日期转换成年龄
	 * 
	 * @param birthday
	 *            出生日期,格式{@link DatePattern#onlyDate}
	 * @return 将生日转换成年龄,如果传入的日期格式不正确,则返回null
	 * @since 1.0
	 * @deprecated 待重构,不建议使用
	 */
	public final static Integer convertBirthdayToAge(String birthday){
		String birthdayPattern = "^(?:([0-9]{4}-(?:(?:0?[1,3-9]|1[0-2])-(?:29|30)|" + "((?:0?[13578]|1[02])-31)))|"
				+ "([0-9]{4}-(?:0?[1-9]|1[0-2])-(?:0?[1-9]|1\\d|2[0-8]))|" + "(((?:(\\d\\d(?:0[48]|[2468][048]|[13579][26]))|"
				+ "(?:0[48]00|[2468][048]00|[13579][26]00))-0?2-29)))$";
		if (RegexUtil.match(birthdayPattern, birthday)){
			Date nowDate = new Date();
			return getYear(nowDate) - Integer.parseInt(birthday.substring(0, 4)) + 1;
		}
		return null;
	}

	/**
	 * 将传入的date转换为中国特色日期
	 * <p>
	 * 转换规则,将传入的inDate和 new Date()当前时间比较<br>
	 * 当两者的时间差,(一般inDate小于当前时间 ,暂时不支持大于当前时间)
	 * <ul>
	 * <li>如果时间差为0天,<br>
	 * 如果小时间隔等于0,如果分钟间隔为0,则显示间隔秒 + "秒钟前"<br>
	 * 如果小时间隔等于0,如果分钟间隔不为0,则显示间隔分钟 + "分钟前"<br>
	 * </li>
	 * <li>如果时间差为0天,<br>
	 * 如果小时间隔不等于0,如果inDate的day 和current的day 相等,则显示space_hour + "小时前"<br>
	 * 如果小时间隔不等于0,如果inDate的day 和current的day不相等,则显示"昨天 " + convertDateToString(inDate, "HH:mm")<br>
	 * </li>
	 * <li>如果时间差为1天,且inDate的day+1和currentDate的day 相等,则显示"昨天 HH:mm"</li>
	 * <li>如果时间差为1天,且inDate的day+1和currentDate的day 不相等,则显示"前天 HH:mm"</li>
	 * <li>如果时间差为2天,且inDate的day+2和currentDate的day 相等,则显示"前天 HH:mm"</li>
	 * <li>如果时间差为2天,且inDate的day+2和currentDate的day 不相等,<br>
	 * 1).如果inDate的year和currentDate的year相等,则显示"MM-dd HH:mm"<br>
	 * 2).如果inDate的year和currentDate的year不相等,则显示"yyyy-MM-dd HH:mm"</li>
	 * <li>如果时间差大于2天<br>
	 * 1).如果inDate的year和currentDate的year相等,则显示"MM-dd HH:mm"<br>
	 * 2).如果inDate的year和currentDate的year不相等,则显示"yyyy-MM-dd HH:mm"</li> </li>
	 * </ul>
	 * 
	 * @param inDate
	 *            任意日期(一般inDate小于当前时间 ,暂时不支持大于当前时间)
	 * @return 将date类型属性转换为中国特色日期
	 * @since 1.0
	 */
	public final static String convertDateToChineseDateString(Date inDate){
		Date nowDate = new Date();
		/**************************************************************************************/
		String returnValue = null;
		// 传过来的日期的年份
		int inYear = getYear(inDate);
		// 传过来的日期的月份
		// int inMonth = getMonth(inDate);
		// 传过来的日期的日
		int inDay = getDayOfMonth(inDate);
		/**************************************************************************************/
		// 当前时间的年
		int year = getYear(nowDate);
		// 当前时间的余额
		// int month = getMonth();
		// 当前时间的日
		int day = getDayOfMonth(nowDate);
		/**************************************************************************************/
		// 任意日期和现在相差的毫秒数
		long space_time = getIntervalTime(inDate, nowDate);
		// 相差天数
		int space_day = getIntervalDay(space_time);
		// 相差小时数
		int space_hour = getIntervalHour(space_time);
		// 相差分数
		int space_minute = getIntervalMinute(space_time);
		// 相差秒数
		int space_second = getIntervalSecond(space_time);
		/**************************************************************************************/
		// 间隔一天
		if (space_day == 1){
			if (isEqual(addDay(inDate, 1), nowDate, DatePattern.onlyDate)){
				returnValue = config_date_yesterday + " ";
			}else{
				returnValue = config_date_theDayBeforeYesterday + " ";
			}
			returnValue += date2String(inDate, DatePattern.onlyTime_withoutSecond);
		}
		// 间隔2天
		else if (space_day == 2){
			if (isEqual(addDay(inDate, 2), nowDate, DatePattern.onlyDate)){
				returnValue = config_date_theDayBeforeYesterday + " " + date2String(inDate, DatePattern.onlyTime_withoutSecond);
			}else{
				// 今年
				if (year == inYear){
					returnValue = date2String(inDate, DatePattern.commonWithoutAndYearSecond);
				}else{
					returnValue = date2String(inDate, DatePattern.commonWithoutSecond);
				}
			}
		}
		// 间隔大于2天
		else if (space_day > 2){
			// 今年
			if (year == inYear){
				returnValue = date2String(inDate, DatePattern.commonWithoutAndYearSecond);
			}else{
				returnValue = date2String(inDate, DatePattern.commonWithoutSecond);
			}
		}
		// 间隔0天
		else if (space_day == 0){
			// 小时间隔
			if (space_hour != 0){
				if (inDay == day){
					returnValue = space_hour + config_date_hour + "前";
				}else{
					returnValue = config_date_yesterday + " " + date2String(inDate, DatePattern.onlyTime_withoutSecond);
				}
			}else{
				// 分钟间隔
				if (space_minute == 0){
					returnValue = space_second + config_date_second + "前";
				}else{
					returnValue = space_minute + config_date_minute + "前";
				}
			}
		}
		return returnValue;
	}

	// [end]
	// [start] 转换成特色时间
	/**
	 * 在相同格式下判断两个日期是否相等
	 * 
	 * @param date1
	 *            日期1
	 * @param date2
	 *            日期2
	 * @param datePattern
	 *            格式
	 * @return 相等返回true,不相等则为false
	 * @since 1.0
	 */
	public final static boolean isEqual(Date date1,Date date2,String datePattern){
		return date2String(date1, datePattern).equals(date2String(date2, datePattern));
	}

	/**
	 * 获得两日期之间的间隔,并且转换成直观的表示方式
	 * <p>
	 * (2011-05-19 8:30:40,2011-05-19 11:30:24)-->转换成2小时59分44秒<br>
	 * (2011-05-19 11:31:25.456,2011-05-19 11:30:24.895)pattern_commonWithTime--->1分钟1秒 <br>
	 * 自动增加 天,小时,分钟,秒,毫秒中文文字
	 * 
	 * @param date1
	 *            时间1
	 * @param date2
	 *            时间2
	 * @return 获得两日期之间的间隔,并且转换成直观的表示方式
	 * @since 1.0
	 */
	public final static String getIntervalForView(Date date1,Date date2){
		long space_time = DateUtil.getIntervalTime(date1, date2);
		return getIntervalForView(space_time);
	}

	/**
	 * 将时间(单位毫秒),并且转换成直观的表示方式
	 * <p>
	 * 13516-->13秒516毫秒<br>
	 * 自动增加 天,小时,分钟,秒,毫秒中文文字
	 * 
	 * @param space_time
	 *            单位毫秒
	 * @return 将时间(单位毫秒),并且转换成直观的表示方式<br>
	 *         如果 space_time 是0 直接返回0
	 * @since 1.0
	 */
	public final static String getIntervalForView(long space_time){
		if (0 == space_time){
			return "0";
		}
		// **************************************************************************************
		// 间隔天数
		long space_day = getIntervalDay(space_time);
		// 间隔小时 减去间隔天数后,
		long space_hour = getIntervalHour(space_time) - space_day * 24;
		// 间隔分钟 减去间隔天数及间隔小时后,
		long space_minute = getIntervalMinute(space_time) - (space_day * 24 + space_hour) * 60;
		// 间隔秒 减去间隔天数及间隔小时,间隔分钟后,
		long space_second = getIntervalSecond(space_time) - ((space_day * 24 + space_hour) * 60 + space_minute) * 60;
		// 间隔秒 减去间隔天数及间隔小时,间隔分钟后,
		long space_millisecond = space_time - (((space_day * 24 + space_hour) * 60 + space_minute) * 60 + space_second) * 1000;
		// **************************************************************************************
		StringBuilder stringBuilder = new StringBuilder();
		if (0 != space_day){
			stringBuilder.append(space_day + config_date_day);
		}
		if (0 != space_hour){
			stringBuilder.append(space_hour + config_date_hour);
		}
		if (0 != space_minute){
			stringBuilder.append(space_minute + config_date_minute);
		}
		if (0 != space_second){
			stringBuilder.append(space_second + config_date_second);
		}
		if (0 != space_millisecond){
			stringBuilder.append(space_millisecond + config_date_millisecond);
		}
		return stringBuilder.toString();
	}

	/**
	 * 两个时间相差的小时数
	 * 
	 * @param space_time
	 *            间隔毫秒
	 * @return 相差的小时数
	 * @since 1.0
	 */
	public final static int getIntervalHour(long space_time){
		// 相差小时数
		return (int) (space_time / (60 * 60 * 1000));
	}

	/**
	 * 两个时间相差的分数
	 * 
	 * @param space_time
	 *            间隔毫秒
	 * @return 相差的分数
	 * @since 1.0
	 */
	public final static int getIntervalMinute(long space_time){
		// 相差分数
		return (int) (space_time / (60 * 1000));
	}

	/**
	 * 两个时间相差的秒数
	 * 
	 * @param space_time
	 *            间隔毫秒
	 * @return 相差的秒数
	 * @since 1.0
	 */
	public final static int getIntervalSecond(long space_time){
		// 相差秒数
		return (int) (space_time / 1000);
	}

	/**
	 * 两个时间相差的的小时数
	 * 
	 * @param date1
	 *            date1
	 * @param date2
	 *            date2
	 * @return 相差的小时数
	 * @since 1.0
	 */
	public final static int getIntervalHour(Date date1,Date date2){
		return getIntervalHour(getIntervalTime(date1, date2));
	}

	/**
	 * 两个时间相差的天数
	 * 
	 * @param space_time
	 *            间隔毫秒
	 * @return 相差的天数
	 * @since 1.0
	 */
	public final static int getIntervalDay(long space_time){
		// 相差天数
		return (int) (space_time / (24 * 60 * 60 * 1000));
	}

	/**
	 * 两个时间相差的的天数
	 * 
	 * @param date1
	 *            date1
	 * @param date2
	 *            date2
	 * @return 相差的天数
	 * @since 1.0
	 */
	public final static int getIntervalDay(String date1,String date2,String datePattern){
		Date date_1 = string2Date(date1, datePattern);
		Date date_2 = string2Date(date2, datePattern);
		return getIntervalDay(getIntervalTime(date_1, date_2));
	}

	/**
	 * 两个时间相差的的天数
	 * 
	 * @param date1
	 *            date1
	 * @param date2
	 *            date2
	 * @return 相差的天数
	 * @since 1.0
	 */
	public final static int getIntervalDay(Date date1,Date date2){
		return getIntervalDay(getIntervalTime(date1, date2));
	}

	/**
	 * 获得两个日期时间的日期间隔时间集合,用于统计日报表<br>
	 * 返回的List 为 LinkedList,日期按照顺序排列
	 * 
	 * @param fromDate
	 *            开始时间
	 * @param toDate
	 *            结束时间
	 * @param datePattern
	 *            时间模式
	 * @return
	 * @since 1.0
	 */
	public final static List<Date> getIntervalDayList(String fromDate,String toDate,String datePattern){
		List<Date> dateList = new LinkedList<Date>();
		/***************************************************************/
		Date begin_Date = string2Date(fromDate, datePattern);
		Date end_Date = string2Date(toDate, datePattern);
		// ******重置时间********
		Date beginDateReset = CalendarUtil.getResetDate_byDay(begin_Date);
		Date endDateReset = CalendarUtil.getResetDate_byDay(end_Date);
		/***************************************************************/
		// 相隔的天数
		int intervalDay = getIntervalDay(beginDateReset, endDateReset);
		/***************************************************************/
		Date minDate = beginDateReset;
		if (beginDateReset.equals(endDateReset)){
			minDate = beginDateReset;
		}else if (beginDateReset.before(endDateReset)){
			minDate = beginDateReset;
		}else{
			minDate = endDateReset;
		}
		/***************************************************************/
		dateList.add(minDate);
		/***************************************************************/
		if (intervalDay > 0){
			for (int i = 0; i < intervalDay; ++i){
				dateList.add(addDay(minDate, i + 1));
			}
		}
		/***************************************************************/
		return dateList;
	}

	/**
	 * 两个时间相差的毫秒数,不管date1是否早于还是晚于date2,均返回绝对值
	 * 
	 * @param date1
	 *            date1
	 * @param date2
	 *            date2
	 * @return 两个时间相差的毫秒数,不管date1是否早于还是晚于date2,均返回绝对值
	 * @since 1.0
	 */
	public final static long getIntervalTime(Date date1,Date date2){
		return Math.abs(getTime(date2) - getTime(date1));
	}

	// [end]

	/**
	 * 将date转成Calendar
	 * 
	 * @param date
	 *            date
	 * @return Calendar
	 */
	public static Calendar toCalendar(Date date){
		Calendar calendar = new GregorianCalendar();
		calendar.setTime(date);
		return calendar;
	}
}